package com.yan.design.java8.k5;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.*;

/**
 * 5 基础
 *      1. this 对象
 *      2. Arrays
 *      3. 注解
 *      4. StringBuilder
 *      5. Math 数值运算
 *      6. 集合
 *      7. Collections 工具类
 * @author shengren.yan
 * @create 2022-08-17
 */
public class util {

    // 1-5
    public static void main(String[] args) {
        // 1. this 谁调用，谁就是当前对象

        // 2. Arrays  来源  java.util包
        int[] ints = {1,5,28,21,18};
        Arrays.sort(ints); // 正序快速排序
        System.out.println(ints);
        // 可变参数 ... 底层就是数组
        // public void add(int ... a);

        // 3. 注解
        // @Override  重写的方法
        // @Deprecated  表示这个方法过时了，有一个删除线，但可以使用
        // @SuppressWarnings("unused")  取消警告，抑制编译器警告

        // 4.StringBuilder  StringBuffer 线程安全
        StringBuilder s = new StringBuilder();
        s.append("a").append("b").append("c");  // 追加
        s.insert(2,"h");            // 在下标为3的位置上，增加h
        s.replace(1,3,"hhh");  // 从1 - 6的位置，替换成hhh
        s.indexOf("true");   // 查询有没有这个字符 ，lastIndexOf
        String s1 = s.substring(1,3);          // 从1-6的位置，截取
        s.delete(1,3);      // 从1-3 删除掉
        s.deleteCharAt(3);  // 删除下标是3的字符

        // 自动装箱
        Integer in1 =100;  Integer in2 =100; // in1 = in2 true 如果大于127，为false  因为Integer默认缓存是127，超过就new 对象
        BigInteger b = new BigInteger("1");  // 比 Integer 精度更大
        BigDecimal bd = new BigDecimal(1);   // 小数的精度

        // 5 Math
        Math.ceil(11.2);  // 向上取整  12
        Math.floor(11.2); // 向下取整  11
        Math.round(11.2); // 四舍五入  11
        Math.abs(11.3);   // 绝对值
        Math.max(11,12);  // 返回最大的数
        Math.min(11,12);  // 返回最小的数
        Math.random();    // 返回随机数  0 - 1 直接的小数
        int i = (int) Math.random() * 100;  // 生产 1 - 100 的随机数
    }


    // 6 - 7
    public static void test1(){
        // 6 集合
        // Conllection - List （有序） - Set （无序）
        //    List - ArrayList （查询快-底层数组 - 因为数组在内存空间是连续的）
        //         - Vector 线程安全，效率低
        //         - LinkedList（查询慢-增删快，底层链表）
        //    Set  - HashSet （判断元素是否存在 - 先比较hashcode,若不在 再比较equals进行比较内容 ）
        //                      jdk1.7 数组 + 链表   jdk1.8 数组 + 链表 + 红黑树
        //                             数组默认长度是16 链表 大于7（8）变成红黑树  加载因子是0.75
        //         - TreeSet 拥有指定排序方式
        //           HashSet  - LinkHashSet （多了维护链表元素的顺序，遍历效率高于HashSet，增删慢）
        // Map - HashMap
        //     - Hashtable （线程安全，不能有null作为key）
        //     - TreeMap 根据key自然排序
        //               自然排序 Comparable接口   定制排序 Comparator接口
        //       HashMap - LinkedHashMap （多了维护链表元素的顺序，遍历效率高于HashMap，增删慢）
        List<Integer> integers = Arrays.asList(1, 2, 3);    // 数组转list
        Integer[] objects = (Integer[]) integers.toArray(); // list转数组
        // integers.add();  integers.addAll(); // 新增
        boolean aa = integers.contains("aa");  // 是否包含aa
        integers.remove("aa");             //  删除  - 如果是对象，需要重新equals方法
        // integers.retainAll(integers);       // 两个集合 取交集
        List<Integer> integers1 = integers.subList(1, 3); // 截取集合1-3位置的数据，包含头，不包含尾

        // LinkedList 的方法
        LinkedList<Integer> integers2 = new LinkedList<>();
        integers2.addFirst(1);
        integers2.getFirst();  integers2.getLast();
        integers2.removeFirst();
        // 堆栈：先进后出  队列：先进先出

        // Comparable 自然排序  ，实现Comparable接口，重写 compareTo方法 ，Uo类上查看
        // 需要定制排序，创建一个类，实现Comparator接口，重写compare（o1,o2）方法

        // Map
        Map map = new HashMap();
        map.keySet();  // 获取所有keys

        // 7. Collections 工具类
        Collections.reverse(integers1); // list反转
        Collections.shuffle(integers1); // list随机顺序
        Collections.sort(integers);     // 自然排序  参数2 定义排序，传递Comparator
        Collections.swap(integers,1,3);  // 位置交换，将1和3的位置交换

        Collections.max(integers1);  // 最大值 ，参数2,传递Comparator 按照这个方式比较
        Collections.min(integers1);  // 最小值， 同上
        int aa1 = Collections.frequency(integers, "AA");  // 该list中出现"AA"的次数
        Collections.replaceAll(integers,3,4); // 将list中的全部的3替换成4。替换所有的旧值
        Collections.copy(integers,new ArrayList<>(integers.size())); // list 复制

        // 泛型 - <> 只能写引用数据类型
        // 通配符 <?> 可以接受任何类型的泛型集合
        // 通配符 <? extends 父类> 可以接受泛型-父类下的 子类   常用查询
        // 通配符 <? super 父类> 可以接受泛型-子类下的 父类   常用新增
//        public static void show(List<? extends Persion> list){
//            for(Persion p :list){...}
//        }
//        public static void show(List<? super Persion> list){
//            list.add(new Man());
//        }
//        获取list
//        Collection<T> values = map.values();
//        List<T> ll  =new ArrayList<>();
//        ll.addAll(values);

    }


}
